home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / Softshoe / Lisa's Mac Parts / Method / Functor.h < prev    next >
Text File  |  2000-06-23  |  4KB  |  164 lines
  1. // Functor.h
  2.  
  3. #ifndef Functor_h
  4. #define Functor_h
  5.  
  6. template < class Signature >
  7. class Functor
  8.   {
  9.     private:
  10.         // not implemented:
  11.             Functor( const Functor& );
  12.             void operator=( const Functor& );
  13.   };
  14.  
  15. template < class R >
  16. class Functor< R (*)() >
  17.   {
  18.     protected:
  19.         Functor()                                    {}
  20.         Functor( const Functor& )                {}
  21.         ~Functor()                                    {}
  22.         void operator=( const Functor& )        {}
  23.     
  24.     public:
  25.         virtual R operator()() = 0;
  26.   };
  27.  
  28. template < class R, class P0 >
  29. class Functor< R (*)( P0 ) >
  30.   {
  31.     protected:
  32.         Functor()                                    {}
  33.         Functor( const Functor& )                {}
  34.         ~Functor()                                    {}
  35.         void operator=( const Functor& )        {}
  36.     
  37.     public:
  38.         virtual R operator()( P0 ) = 0;
  39.   };
  40.  
  41. template < class R, class P0, class P1 >
  42. class Functor< R (*)( P0, P1 ) >
  43.   {
  44.     protected:
  45.         Functor()                                    {}
  46.         Functor( const Functor& )                {}
  47.         ~Functor()                                    {}
  48.         void operator=( const Functor& )        {}
  49.     
  50.     public:
  51.         virtual R operator()( P0, P1 ) = 0;
  52.   };
  53.  
  54. template < class R, class P0, class P1, class P2 >
  55. class Functor< R (*)( P0, P1, P2 ) >
  56.   {
  57.     protected:
  58.         Functor()                                    {}
  59.         Functor( const Functor& )                {}
  60.         ~Functor()                                    {}
  61.         void operator=( const Functor& )        {}
  62.     
  63.     public:
  64.         virtual R operator()( P0, P1, P2 ) = 0;
  65.   };
  66.  
  67. template < class R, class P0, class P1, class P2, class P3 >
  68. class Functor< R (*)( P0, P1, P2, P3 ) >
  69.   {
  70.     protected:
  71.         Functor()                                    {}
  72.         Functor( const Functor& )                {}
  73.         ~Functor()                                    {}
  74.         void operator=( const Functor& )        {}
  75.     
  76.     public:
  77.         virtual R operator()( P0, P1, P2, P3 ) = 0;
  78.   };
  79.  
  80. template < class R, class P0, class P1, class P2, class P3, class P4 >
  81. class Functor< R (*)( P0, P1, P2, P3, P4 ) >
  82.   {
  83.     protected:
  84.         Functor()                                    {}
  85.         Functor( const Functor& )                {}
  86.         ~Functor()                                    {}
  87.         void operator=( const Functor& )        {}
  88.     
  89.     public:
  90.         virtual R operator()( P0, P1, P2, P3, P4 ) = 0;
  91.   };
  92.  
  93. template < class R, class P0, class P1, class P2, class P3, class P4,
  94.                           class P5 >
  95. class Functor< R (*)( P0, P1, P2, P3, P4, P5 ) >
  96.   {
  97.     protected:
  98.         Functor()                                    {}
  99.         Functor( const Functor& )                {}
  100.         ~Functor()                                    {}
  101.         void operator=( const Functor& )        {}
  102.     
  103.     public:
  104.         virtual R operator()( P0, P1, P2, P3, P4, P5 ) = 0;
  105.   };
  106.  
  107. template < class R, class P0, class P1, class P2, class P3, class P4,
  108.                           class P5, class P6 >
  109. class Functor< R (*)( P0, P1, P2, P3, P4, P5, P6 ) >
  110.   {
  111.     protected:
  112.         Functor()                                    {}
  113.         Functor( const Functor& )                {}
  114.         ~Functor()                                    {}
  115.         void operator=( const Functor& )        {}
  116.     
  117.     public:
  118.         virtual R operator()( P0, P1, P2, P3, P4, P5, P6 ) = 0;
  119.   };
  120.  
  121. template < class R, class P0, class P1, class P2, class P3, class P4,
  122.                           class P5,  class P6, class P7 >
  123. class Functor< R (*)( P0, P1, P2, P3, P4, P5, P6, P7 ) >
  124.   {
  125.     protected:
  126.         Functor()                                    {}
  127.         Functor( const Functor& )                {}
  128.         ~Functor()                                    {}
  129.         void operator=( const Functor& )        {}
  130.     
  131.     public:
  132.         virtual R operator()( P0, P1, P2, P3, P4, P5, P6, P7 ) = 0;
  133.   };
  134.  
  135. template < class R, class P0, class P1, class P2, class P3, class P4,
  136.                           class P5, class P6, class P7, class P8 >
  137. class Functor< R (*)( P0, P1, P2, P3, P4, P5, P6, P7, P8 ) >
  138.   {
  139.     protected:
  140.         Functor()                                    {}
  141.         Functor( const Functor& )                {}
  142.         ~Functor()                                    {}
  143.         void operator=( const Functor& )        {}
  144.     
  145.     public:
  146.         virtual R operator()( P0, P1, P2, P3, P4, P5, P6, P7, P8 ) = 0;
  147.   };
  148.  
  149. template < class R, class P0, class P1, class P2, class P3, class P4,
  150.                           class P5, class P6, class P7, class P8, class P9 >
  151. class Functor< R (*)( P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 ) >
  152.   {
  153.     protected:
  154.         Functor()                                    {}
  155.         Functor( const Functor& )                {}
  156.         ~Functor()                                    {}
  157.         void operator=( const Functor& )        {}
  158.     
  159.     public:
  160.         virtual R operator()( P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 ) = 0;
  161.   };
  162.  
  163. #endif
  164.